Zazama / node-id3

import {

    Flags,

    getHeaderSize,

    FrameHeader

} from './FrameHeader'

import * as GenericFrames from './frames/generic'

import { Frames } from './frames/frames'

import * as ID3Util from './ID3Util'

import { deduplicate, isBuffer, isKeyOf } from "./util"

type HeaderInfo = {

    identifier: string

    headerSize: number

    bodySize: number

    flags: Flags

}

export class Frame {

    identifier: string

    private value: unknown

    flags: Flags

    constructor(identifier: string, value: unknown, flags: Flags = {}) {

        this.identifier = identifier

        this.value = value

        this.flags = flags

    }

    static createFromBuffer = createFromBuffer

    getValue() {

        return this.value

    }

}

function createFromBuffer(

    frameBuffer: Buffer,

    version: number

): Frame | null {

    const headerSize = getHeaderSize(version)

    // Specification requirement

    if (frameBuffer.length < headerSize + 1) {

        return null

    }

    const headerBuffer = frameBuffer.subarray(0, headerSize)

    const header: HeaderInfo = {

        headerSize,

        ...FrameHeader.createFromBuffer(headerBuffer, version)

    }

    if (header.flags.encryption) {

        return null

    }

    const body = decompressBody(

        header.flags,

        getDataLength(header, frameBuffer),

        getBody(header, frameBuffer)

    )

    if (body) {

        const value = makeFrameValue(header.identifier, body, version)

        if (value) {

            return new Frame(header.identifier, value, header.flags)

        }

    }

    return null

}

export function makeFrameBuffer(identifier: string, value: unknown) {

    if (isKeyOf(identifier, Frames)) {

        return handleMultipleAndMakeFrameBuffer(

            identifier,

            value,

            Frames[identifier].create

        )

    }

    if (identifier.startsWith('T')) {

        return GenericFrames.GENERIC_TEXT.create(identifier, value)

    }

    if (identifier.startsWith('W')) {

        return handleMultipleAndMakeFrameBuffer(

            identifier,

            value,

            url => GenericFrames.GENERIC_URL.create(identifier, url),

            deduplicate

        )

    }

    return null

}

function handleMultipleAndMakeFrameBuffer<

    // eslint-disable-next-line @typescript-eslint/no-explicit-any

    Create extends (value: any, index: number) => Buffer | null

>(

    identifier: string,

    data: unknown,

    create: Create,

    deduplicate = (values: ([Parameters<Create>])[]) => values

) {

    const values = makeValueArray(identifier, data)

    const frames = deduplicate(values)

        .map(create)

        .filter(isBuffer)

    return frames.length ? Buffer.concat(frames) : null

}

/**

 * Throws if an array is given but not expected, i.e. the contract is not

 * respected, otherwise always return an array.

 */

function makeValueArray(identifier: string, data: unknown) {

    const isMultiple = ID3Util.getSpecOptions(identifier).multiple

    const isArray = Array.isArray(data)

    if (!isMultiple && isArray) {

        throw new TypeError(`Unexpected array for frame ${identifier}`)

    }

    return isMultiple && isArray ? data : [data]

}

function makeFrameValue(identifier:string, body: Buffer, version: number) {

    if (isKeyOf(identifier, Frames)) {

        return Frames[identifier].read(body, version)

    }

    if (identifier.startsWith('T')) {

        return GenericFrames.GENERIC_TEXT.read(body)

    }

    if (identifier.startsWith('W')) {

        return GenericFrames.GENERIC_URL.read(body)

    }

    return null

}

function getBody({flags, headerSize, bodySize}: HeaderInfo, buffer: Buffer) {

    const bodyOffset = flags.dataLengthIndicator ? 4 : 0

    const bodyStart = headerSize + bodyOffset

    const bodyEnd = bodyStart + bodySize - bodyOffset

    const body = buffer.subarray(bodyStart, bodyEnd)

    if (flags.unsynchronisation) {

        // This method should stay in ID3Util for now because it's also used

        // in the Tag's header which we don't have a class for.

        return ID3Util.processUnsynchronisedBuffer(body)

    }

    return body

}

function getDataLength({flags, headerSize}: HeaderInfo, buffer: Buffer) {

    return flags.dataLengthIndicator ? buffer.readInt32BE(headerSize) : 0

}

function decompressBody(

    {compression}: Flags,

    dataLength: number,

    body: Buffer

) {

    return compression ? decompressBuffer(body, dataLength) : body

}